package api

import (
	"fmt"
	"ginchat/models/mysqlModel"
	"ginchat/models/requstModel"
	"ginchat/service"
	"ginchat/utils/ginRespond"
	"github.com/asaskevich/govalidator"
	"github.com/gin-gonic/gin"
	"github.com/gorilla/websocket"
	"net/http"
	"strconv"
)

// GetIndex
// @Tags UserApi
// @Summary 获取首页
// @Schemes
// @Description	Get 请求, 发送 json 类型的数据, 参数在消息体中
// @Accept json
// @Produce json
// @Success 200 {string} json{"code","data"}
// @Router	/index [get]
func GetIndex(c *gin.Context){
	ginRespond.Respond(c,200,"获取首页成功",nil)
}

// GetUserList
// @Tags UserApi
// @Summary 获取所有用户数据
// @Schemes
// @Description	Get 请求, 发送 json 类型的数据, 参数在消息体中
// @Accept json
// @Produce json
// @Success 200 {string} json{"code","message","data"}
// @Router	/user/getUserList [get]
func GetUserList(c *gin.Context){
	data,err := service.GetUserList()
	if err != nil{
		ginRespond.Respond(c,400,err.Error(),nil)
		return
	}
	ginRespond.Respond(c,200,"查询成功",data)
}

// CreateUser
// @Tags UserApi
// @Summary 创建用户
// @Schemes
// @Description	Post 请求, 发送 json 类型的数据, 参数在消息体中
// @Accept json
// @Produce json
// @Param	userCreateMessage body  requstModel.CreateUserRequst  true "用户信息"
// @Success 200 {string} json{"code","message","data"}
// @Router	/user/createUser [post]
func CreateUser(c *gin.Context){
	requstMode := requstModel.CreateUserRequst{}
	if err := c.ShouldBindJSON(&requstMode);err != nil{
		ginRespond.Respond(c,400,err.Error(),nil)
		return
	}

	//用validator库进行验证参数
	if _,err := govalidator.ValidateStruct(requstMode);err != nil{
		ginRespond.Respond(c,400,err.Error(),nil)
		return
	}

	var err error
	data  := mysqlModel.UserBasic{}
	if data,err = service.CreateUser(requstMode ); err != nil{
		ginRespond.Respond(c,400,err.Error(),nil)
		return
	}
	ginRespond.Respond(c,200,"用户创建成功",data)
}

// UserLog
// @Tags UserApi
// @Summary 用户登录
// @Schemes
// @Description	Post 请求, 发送 json 类型的数据, 参数在消息体中
// @Accept mpfd
// @Produce json
// @Param	name formData  string  true "用户姓名"
// @Param	password formData  string  true "用户密码"
// @Success 200 {string} json{"code","message","data"}
// @Router	/user/log [post]
func UserLog(c *gin.Context){
	name := c.PostForm("name")
	password := c.PostForm("password")

	fmt.Println("参数：",name,password)

	var err error
	data := mysqlModel.UserBasic{}
	if data,err = service.UserLog(name, password);err != nil{
		ginRespond.Respond(c,400,err.Error(),data)
		return
	}

	ginRespond.Respond(c,200,"用户登录成功",data)
}
// DeleteUser
// @Tags UserApi
// @Summary 删除用户
// @Schemes
// @Description	Delete 请求, 发送 json 类型的数据, 参数在消息体中
// @Accept json
// @Produce json
// @Param	id body  requstModel.DeleteUserRequst  true "用户id"
// @Success 200 {string} json{"code","message","data"}
// @Router	/user/deleteUser [delete]
func DeleteUser(c *gin.Context){
	requstMode := requstModel.DeleteUserRequst{}
	if err := c.ShouldBindJSON(&requstMode);err != nil{
		ginRespond.Respond(c,400,err.Error(),nil)
		return
	}

	if err := service.DeleteUser(requstMode.Id);err != nil{
		ginRespond.Respond(c,400,err.Error(),nil)
		return
	}
	ginRespond.Respond(c,200,"用户删除成功",nil)
}

// UpdateUser
// @Tags UserApi
// @Summary 修改用户
// @Schemes
// @Description	Post 请求, 发送 formData 类型的数据, 参数在消息体中
// @Accept      mpfd
// @Produce     json
// @param	id formData int false "id"
// @param	name formData string false "name"
// @param	password formData string false "password"
// @param	email formData string false "email"
// @param	phone formData string false "phone"
// @Success 200 {string} json{"code","message","data"}
// @Router	/user/updateUser [post]
func UpdateUser(c *gin.Context){
	requstMode := requstModel.UpdateUserRequst{}

	id,_ := strconv.Atoi(c.PostForm("id"))
	requstMode.Id = id
	requstMode.Name = c.PostForm("name")
	requstMode.Password = c.PostForm("password")
	requstMode.Email = c.PostForm("email")
	requstMode.Phone = c.PostForm("phone")

	if _,err := govalidator.ValidateStruct(requstMode);err != nil{
		ginRespond.Respond(c,400,err.Error(),nil)
		return
	}
	if err := service.UpdateUser(requstMode);err != nil{
		ginRespond.Respond(c,400,err.Error(),nil)
		return
	}
	ginRespond.Respond(c,200,"修改用户成功",nil)
}

// SearchFriend
// @Tags UserApi
// @Summary 查找好友列表
// @Schemes
// @Description	Get 请求, 发送 formData 类型的数据, 参数在消息体中
// @Accept      mpfd
// @Produce     json
// @param	id formData string false "id"
// @Success 200 {string} json{"code","message","data"}
// @Router	/user/searchFriend [get]
func SearchFriend(c *gin.Context){
	id := c.PostForm("id")
	userId,err := strconv.Atoi(id)
	if err != nil{
		ginRespond.Respond(c,400,err.Error(),nil)
		return
	}
	data := service.SearchFriend(uint(userId))
	ginRespond.Respond(c,200,"查找好友列表成功",data)
}

// 用于防止跨站点伪造连接。如果请求头有 "Origin",
// 则用此函数校验支付支持当前 Host, 支持返回 true, 不支持返回 false。
// 如果为 nil, 则使用安全的默认值。
var upGrade = &websocket.Upgrader{
	CheckOrigin: func(r *http.Request) bool {
		// 允许跨站, 不校验 Origin 请求头
		return true
	},
}
func SendMsg(c *gin.Context){
	// 把 HTTP请求 升级转换为 WebSocket连接对象, 并写出状态行和响应头 (responseHeader 表示额外写到客户端的响应头)
	wsConn,err := upGrade.Upgrade(c.Writer,c.Request,nil)
	if err != nil{
		fmt.Println("upGrade.Upgrade failed:",err)
		return
	}
	//关闭wsConn连接
	defer func(wsConn *websocket.Conn){
		if err := wsConn.Close(); err != nil{
			fmt.Println("wsConn.Close failed:",err)
			return
		}
	}(wsConn)
	//处理消息
	service.MsgHandler(wsConn,c)
}


func SendUserMsg(c *gin.Context){
	//1.获取用户id
	id := c.Query("userId")
	userId,_ := strconv.ParseInt(id,10,64)
	service.Chat(c.Writer,c.Request,int(userId))
}

func Upload(c *gin.Context){
	url,err := service.Upload(c.Request)
	if err != nil{
		ginRespond.Respond(c,400,err.Error(),nil)
		return
	}
	ginRespond.Respond(c,200,"图片发送成功",url)
}

func AddFriend(c *gin.Context){
	userId,_ := strconv.Atoi(c.Request.FormValue("userId"))
	targetId,_ := strconv.Atoi(c.Request.FormValue("targetId"))
	code,data := service.AddFriend(uint(userId),uint(targetId))
	if code == 1{
		ginRespond.Respond(c,400,"添加朋友失败",data)
		return
	}
	ginRespond.Respond(c,200,"添加朋友成功",data)
}

func CreateCommunity(c *gin.Context){
	//获取创始人Id
	ownerId,_ := strconv.Atoi(c.Request.FormValue("owner_id"))
	//获取群名称
	name := c.Request.FormValue("name")
	community := mysqlModel.Community{
		OwnerId: uint(ownerId),
		Name: name,
	}
	code,msg := service.CreateCommunity(community)
	if code == -1{
		ginRespond.Respond(c,400,msg,nil)
		return
	}
	ginRespond.Respond(c,200,msg,nil)
}

func Loadcomunity(c *gin.Context){
	owner_id,_ := strconv.Atoi(c.Request.FormValue("owner_id"))
	err,data := service.LoadCommunity(uint(owner_id))
	if err != nil{
		ginRespond.Respond(c,400, err.Error(),nil)
		return
	}
	ginRespond.Respond(c,200,"群列表查询成功",data)
}

func JoinGroup(c *gin.Context){

}